//! 轻量级连接处理器
//! 
//! 核心设计原则：
//! 1. 协议层完全同步，不依赖Tokio
//! 2. 不使用OS线程，避免内存爆炸
//! 3. 纯同步调用，由Tokio网络层直接调用
//! 4. 每个连接仅占用几KB内存，达到协程级别的轻量化

use std::collections::VecDeque;
use crate::protocol::{RespParser};
use crate::storage::{Command, CommandResult, SingleThreadCommandDispatcher};
use crate::event::ConnectionId;

/// 连接状态
#[derive(Debug, Clone)]
pub enum ConnectionState {
    /// 活跃状态
    Active,
    /// 关闭状态
    Closed,
    /// 错误状态
    Error(String),
}

/// 轻量级连接处理器
/// 
/// 核心特性：
/// 1. 纯同步设计，不使用线程或协程
/// 2. 无状态设计，内存占用极小（几KB）
/// 3. 由Tokio网络层直接调用，不依赖异步运行时
/// 4. 完全的协议层与网络层解耦
#[derive(Debug)]
pub struct LightweightConnectionHandler {
    /// 连接ID
    connection_id: ConnectionId,
    /// RESP协议解析器
    resp_parser: RespParser,
    /// 待处理命令队列
    pending_commands: VecDeque<Box<dyn Command>>,
    /// 连接状态
    state: ConnectionState,
}

impl LightweightConnectionHandler {
    /// 创建新的轻量级连接处理器
    /// 
    /// 内存占用：仅几KB，达到协程级别的轻量化
    pub fn new(connection_id: ConnectionId) -> Self {
        Self {
            connection_id,
            resp_parser: RespParser::new(),
            pending_commands: VecDeque::new(),
            state: ConnectionState::Active,
        }
    }

    /// 处理接收到的数据（纯同步，无线程）
    /// 
    /// 直接由Tokio网络层调用，返回所有需要发送的响应
    pub fn handle_data(
        &mut self, 
        data: &[u8], 
        storage_dispatcher: &mut SingleThreadCommandDispatcher
    ) -> Result<Vec<Vec<u8>>, String> {
        // 检查连接状态
        if !matches!(self.state, ConnectionState::Active) {
            return Err("连接已关闭".to_string());
        }

        let mut responses = Vec::new();

        // 1. 将数据喂给RESP解析器
        self.resp_parser.feed_data(data);

        // 2. 解析所有可能的命令
        while let Ok(Some(resp_value)) = self.resp_parser.parse_value() {
            match self.resp_parser.resp_to_command(resp_value) {
                Ok(command) => {
                    self.pending_commands.push_back(command);
                }
                Err(e) => {
                    eprintln!("❌ 连接 {} 命令解析失败: {:?}", self.connection_id, e);
                    responses.push(b"-ERR Protocol error\r\n".to_vec());
                }
            }
        }

        // 3. 处理所有待处理的命令（同步执行）
        while let Some(command) = self.pending_commands.pop_front() {
            match self.execute_command(command, storage_dispatcher) {
                Ok(response) => responses.push(response),
                Err(e) => {
                    eprintln!("❌ 连接 {} 命令执行失败: {}", self.connection_id, e);
                    responses.push(format!("-ERR {e}\r\n").into_bytes());
                }
            }
        }

        Ok(responses)
    }

    /// 执行单个命令（纯同步）
    fn execute_command(
        &self,
        command: Box<dyn Command>,
        storage_dispatcher: &mut SingleThreadCommandDispatcher,
    ) -> Result<Vec<u8>, String> {
        let command_name = command.name().to_string();

        // 直接在当前线程执行命令（无异步，无线程切换）
        match storage_dispatcher.dispatch_command(command) {
            Ok(()) => {
                // 模拟命令执行结果（实际应该从存储层获取）
                let result = match command_name.as_str() {
                    "PING" => CommandResult::String("PONG".to_string()),
                    "SET" => CommandResult::Ok,
                    "GET" => CommandResult::String("mock_value".to_string()),
                    _ => CommandResult::Ok,
                };

                // 将结果转换为RESP格式
                let response_data = result.to_resp().into_bytes();
                println!("📝 连接 {} 命令 {} 已处理", self.connection_id, command_name);
                Ok(response_data)
            }
            Err(e) => Err(e.to_string()),  // 修复类型不匹配问题
        }
    }

    /// 关闭连接处理器
    pub fn close(&mut self) -> Result<(), String> {
        self.state = ConnectionState::Closed;
        self.pending_commands.clear();
        println!("✅ 连接 {} 轻量级处理器已关闭", self.connection_id);
        Ok(())
    }

    /// 获取连接ID
    pub fn connection_id(&self) -> ConnectionId {
        self.connection_id
    }

    /// 获取连接状态
    pub fn state(&self) -> &ConnectionState {
        &self.state
    }

    /// 检查是否有待处理的命令
    pub fn has_pending_commands(&self) -> bool {
        !self.pending_commands.is_empty()
    }

    /// 获取内存使用统计（调试用）
    pub fn memory_usage(&self) -> usize {
        // 估算内存使用：解析器 + 命令队列 + 基本结构
        std::mem::size_of::<Self>() + 
        self.pending_commands.len() * 128 + // 估算每个命令128字节
        1024 // 解析器缓冲区
    }
}

/// 轻量级协议服务器
/// 
/// 管理所有轻量级连接处理器，每个连接仅占用几KB内存
pub struct LightweightProtocolServer {
    /// 存储分发器（单线程，无锁）
    storage_dispatcher: SingleThreadCommandDispatcher,
    /// 连接计数器
    connection_counter: u64,
}

impl LightweightProtocolServer {
    /// 创建新的轻量级协议服务器
    pub fn new(storage_dispatcher: SingleThreadCommandDispatcher) -> Self {
        Self {
            storage_dispatcher,
            connection_counter: 0,
        }
    }

    /// 创建新连接处理器（轻量级，几KB内存）
    pub fn create_connection(&mut self) -> (ConnectionId, LightweightConnectionHandler) {
        self.connection_counter += 1;
        let connection_id = self.connection_counter;
        let handler = LightweightConnectionHandler::new(connection_id);
        
        println!("🌐 创建轻量级连接 {} (内存: ~{}KB)", 
                connection_id, 
                handler.memory_usage() / 1024);
        
        (connection_id, handler)
    }

    /// 处理连接数据（提供存储分发器的可变引用）
    pub fn handle_connection_data(
        &mut self,
        handler: &mut LightweightConnectionHandler,
        data: &[u8],
    ) -> Result<Vec<Vec<u8>>, String> {
        handler.handle_data(data, &mut self.storage_dispatcher)
    }

    /// 获取活跃连接统计
    pub fn get_stats(&self) -> String {
        format!("轻量级协议服务器 - 总连接数: {}", self.connection_counter)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_lightweight_handler_memory_usage() {
        let handler = LightweightConnectionHandler::new(1);
        let memory_kb = handler.memory_usage() / 1024;
        
        // 验证内存使用在合理范围内（应该远小于OS线程的2-8MB）
        assert!(memory_kb < 100, "轻量级处理器内存使用过大: {memory_kb}KB");
        println!("✅ 轻量级处理器内存使用: {memory_kb}KB");
    }

    #[test]
    fn test_lightweight_handler_basic_functionality() {
        let handler = LightweightConnectionHandler::new(1);
        assert_eq!(handler.connection_id(), 1);
        assert!(matches!(handler.state(), ConnectionState::Active));
        assert!(!handler.has_pending_commands());
    }

    #[test]
    fn test_connection_lifecycle() {
        let mut handler = LightweightConnectionHandler::new(1);
        
        // 测试关闭连接
        assert!(handler.close().is_ok());
        assert!(matches!(handler.state(), ConnectionState::Closed));
    }
}